home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Magazine / Morphos / GCC / lib / gcc-lib / ppc-amigaos / 2.95.1 / sys-include / powerup / ppcpragmas / ahi_pragmas.h next >
C/C++ Source or Header  |  2000-03-13  |  14KB  |  468 lines
  1. /* Automatically generated header! Do not edit! */
  2.  
  3. #ifndef _PPCPRAGMA_AHI_H
  4. #define _PPCPRAGMA_AHI_H
  5. #ifdef __GNUC__
  6. #ifndef _PPCINLINE__AHI_H
  7. #include <powerup/ppcinline/ahi.h>
  8. #endif
  9. #else
  10.  
  11. #ifndef POWERUP_PPCLIB_INTERFACE_H
  12. #include <powerup/ppclib/interface.h>
  13. #endif
  14.  
  15. #ifndef POWERUP_GCCLIB_PROTOS_H
  16. #include <powerup/gcclib/powerup_protos.h>
  17. #endif
  18.  
  19. #ifndef NO_PPCINLINE_STDARG
  20. #define NO_PPCINLINE_STDARG
  21. #endif/* SAS C PPC inlines */
  22.  
  23. #ifndef AHI_BASE_NAME
  24. #define AHI_BASE_NAME AHIBase
  25. #endif /* !AHI_BASE_NAME */
  26.  
  27. #define    AHI_AddAudioMode(Private)    _AHI_AddAudioMode(AHI_BASE_NAME, Private)
  28.  
  29. static __inline ULONG
  30. _AHI_AddAudioMode(void *AHIBase, struct TagItem *Private)
  31. {
  32. struct Caos    MyCaos;
  33.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  34. //    MyCaos.M68kStart    =    NULL;
  35. //    MyCaos.M68kSize        =    0;
  36.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  37. //    MyCaos.PPCStart        =    NULL;
  38. //    MyCaos.PPCSize        =    0;
  39.     MyCaos.a0        =(ULONG) Private;
  40.     MyCaos.caos_Un.Offset    =    (-150);
  41.     MyCaos.a6        =(ULONG) AHIBase;    
  42.     return((ULONG)PPCCallOS(&MyCaos));
  43. }
  44.  
  45. #ifndef NO_PPCINLINE_STDARG
  46. #define AHI_AddAudioModeTags(tags...) \
  47.     ({ULONG _tags[] = { tags }; AHI_AddAudioMode((struct TagItem *)_tags);})
  48. #endif /* !NO_PPCINLINE_STDARG */
  49.  
  50. #define    AHI_AllocAudioA(tagList)    _AHI_AllocAudioA(AHI_BASE_NAME, tagList)
  51.  
  52. static __inline struct AHIAudioCtrl *
  53. _AHI_AllocAudioA(void *AHIBase, struct TagItem *tagList)
  54. {
  55. struct Caos    MyCaos;
  56.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  57. //    MyCaos.M68kStart    =    NULL;
  58. //    MyCaos.M68kSize        =    0;
  59.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  60. //    MyCaos.PPCStart        =    NULL;
  61. //    MyCaos.PPCSize        =    0;
  62.     MyCaos.a1        =(ULONG) tagList;
  63.     MyCaos.caos_Un.Offset    =    (-42);
  64.     MyCaos.a6        =(ULONG) AHIBase;    
  65.     return((struct AHIAudioCtrl *)PPCCallOS(&MyCaos));
  66. }
  67.  
  68. #ifndef NO_PPCINLINE_STDARG
  69. #define AHI_AllocAudio(tags...) \
  70.     ({ULONG _tags[] = { tags }; AHI_AllocAudioA((struct TagItem *)_tags);})
  71. #endif /* !NO_PPCINLINE_STDARG */
  72.  
  73. #define    AHI_AllocAudioRequestA(tagList)    _AHI_AllocAudioRequestA(AHI_BASE_NAME, tagList)
  74.  
  75. static __inline struct AHIAudioModeRequester *
  76. _AHI_AllocAudioRequestA(void *AHIBase, struct TagItem *tagList)
  77. {
  78. struct Caos    MyCaos;
  79.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  80. //    MyCaos.M68kStart    =    NULL;
  81. //    MyCaos.M68kSize        =    0;
  82.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  83. //    MyCaos.PPCStart        =    NULL;
  84. //    MyCaos.PPCSize        =    0;
  85.     MyCaos.a0        =(ULONG) tagList;
  86.     MyCaos.caos_Un.Offset    =    (-120);
  87.     MyCaos.a6        =(ULONG) AHIBase;    
  88.     return((struct AHIAudioModeRequester *)PPCCallOS(&MyCaos));
  89. }
  90.  
  91. #ifndef NO_PPCINLINE_STDARG
  92. #define AHI_AllocAudioRequest(tags...) \
  93.     ({ULONG _tags[] = { tags }; AHI_AllocAudioRequestA((struct TagItem *)_tags);})
  94. #endif /* !NO_PPCINLINE_STDARG */
  95.  
  96. #define    AHI_AudioRequestA(Requester, tagList)    _AHI_AudioRequestA(AHI_BASE_NAME, Requester, tagList)
  97.  
  98. static __inline BOOL
  99. _AHI_AudioRequestA(void *AHIBase, struct AHIAudioModeRequester *Requester, struct TagItem *tagList)
  100. {
  101. struct Caos    MyCaos;
  102.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  103. //    MyCaos.M68kStart    =    NULL;
  104. //    MyCaos.M68kSize        =    0;
  105.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  106. //    MyCaos.PPCStart        =    NULL;
  107. //    MyCaos.PPCSize        =    0;
  108.     MyCaos.a0        =(ULONG) Requester;
  109.     MyCaos.a1        =(ULONG) tagList;
  110.     MyCaos.caos_Un.Offset    =    (-126);
  111.     MyCaos.a6        =(ULONG) AHIBase;    
  112.     return((BOOL)PPCCallOS(&MyCaos));
  113. }
  114.  
  115. #ifndef NO_PPCINLINE_STDARG
  116. #define AHI_AudioRequest(a0, tags...) \
  117.     ({ULONG _tags[] = { tags }; AHI_AudioRequestA((a0), (struct TagItem *)_tags);})
  118. #endif /* !NO_PPCINLINE_STDARG */
  119.  
  120. #define    AHI_BestAudioIDA(tagList)    _AHI_BestAudioIDA(AHI_BASE_NAME, tagList)
  121.  
  122. static __inline ULONG
  123. _AHI_BestAudioIDA(void *AHIBase, struct TagItem *tagList)
  124. {
  125. struct Caos    MyCaos;
  126.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  127. //    MyCaos.M68kStart    =    NULL;
  128. //    MyCaos.M68kSize        =    0;
  129.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  130. //    MyCaos.PPCStart        =    NULL;
  131. //    MyCaos.PPCSize        =    0;
  132.     MyCaos.a1        =(ULONG) tagList;
  133.     MyCaos.caos_Un.Offset    =    (-114);
  134.     MyCaos.a6        =(ULONG) AHIBase;    
  135.     return((ULONG)PPCCallOS(&MyCaos));
  136. }
  137.  
  138. #ifndef NO_PPCINLINE_STDARG
  139. #define AHI_BestAudioID(tags...) \
  140.     ({ULONG _tags[] = { tags }; AHI_BestAudioIDA((struct TagItem *)_tags);})
  141. #endif /* !NO_PPCINLINE_STDARG */
  142.  
  143. #define    AHI_ControlAudioA(AudioCtrl, tagList)    _AHI_ControlAudioA(AHI_BASE_NAME, AudioCtrl, tagList)
  144.  
  145. static __inline ULONG
  146. _AHI_ControlAudioA(void *AHIBase, struct AHIAudioCtrl *AudioCtrl, struct TagItem *tagList)
  147. {
  148. struct Caos    MyCaos;
  149.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  150. //    MyCaos.M68kStart    =    NULL;
  151. //    MyCaos.M68kSize        =    0;
  152.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  153. //    MyCaos.PPCStart        =    NULL;
  154. //    MyCaos.PPCSize        =    0;
  155.     MyCaos.a2        =(ULONG) AudioCtrl;
  156.     MyCaos.a1        =(ULONG) tagList;
  157.     MyCaos.caos_Un.Offset    =    (-60);
  158.     MyCaos.a6        =(ULONG) AHIBase;    
  159.     return((ULONG)PPCCallOS(&MyCaos));
  160. }
  161.  
  162. #ifndef NO_PPCINLINE_STDARG
  163. #define AHI_ControlAudio(a0, tags...) \
  164.     ({ULONG _tags[] = { tags }; AHI_ControlAudioA((a0), (struct TagItem *)_tags);})
  165. #endif /* !NO_PPCINLINE_STDARG */
  166.  
  167. #define    AHI_FreeAudio(AudioCtrl)    _AHI_FreeAudio(AHI_BASE_NAME, AudioCtrl)
  168.  
  169. static __inline void
  170. _AHI_FreeAudio(void *AHIBase, struct AHIAudioCtrl *AudioCtrl)
  171. {
  172. struct Caos    MyCaos;
  173.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  174. //    MyCaos.M68kStart    =    NULL;
  175. //    MyCaos.M68kSize        =    0;
  176.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  177. //    MyCaos.PPCStart        =    NULL;
  178. //    MyCaos.PPCSize        =    0;
  179.     MyCaos.a2        =(ULONG) AudioCtrl;
  180.     MyCaos.caos_Un.Offset    =    (-48);
  181.     MyCaos.a6        =(ULONG) AHIBase;    
  182.     PPCCallOS(&MyCaos);
  183. }
  184.  
  185. #define    AHI_FreeAudioRequest(Requester)    _AHI_FreeAudioRequest(AHI_BASE_NAME, Requester)
  186.  
  187. static __inline void
  188. _AHI_FreeAudioRequest(void *AHIBase, struct AHIAudioModeRequester *Requester)
  189. {
  190. struct Caos    MyCaos;
  191.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  192. //    MyCaos.M68kStart    =    NULL;
  193. //    MyCaos.M68kSize        =    0;
  194.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  195. //    MyCaos.PPCStart        =    NULL;
  196. //    MyCaos.PPCSize        =    0;
  197.     MyCaos.a0        =(ULONG) Requester;
  198.     MyCaos.caos_Un.Offset    =    (-132);
  199.     MyCaos.a6        =(ULONG) AHIBase;    
  200.     PPCCallOS(&MyCaos);
  201. }
  202.  
  203. #define    AHI_GetAudioAttrsA(ID, Audioctrl, tagList)    _AHI_GetAudioAttrsA(AHI_BASE_NAME, ID, Audioctrl, tagList)
  204.  
  205. static __inline BOOL
  206. _AHI_GetAudioAttrsA(void *AHIBase, ULONG ID, struct AHIAudioCtrl *Audioctrl, struct TagItem *tagList)
  207. {
  208. struct Caos    MyCaos;
  209.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  210. //    MyCaos.M68kStart    =    NULL;
  211. //    MyCaos.M68kSize        =    0;
  212.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  213. //    MyCaos.PPCStart        =    NULL;
  214. //    MyCaos.PPCSize        =    0;
  215.     MyCaos.d0        =(ULONG) ID;
  216.     MyCaos.a2        =(ULONG) Audioctrl;
  217.     MyCaos.a1        =(ULONG) tagList;
  218.     MyCaos.caos_Un.Offset    =    (-108);
  219.     MyCaos.a6        =(ULONG) AHIBase;    
  220.     return((BOOL)PPCCallOS(&MyCaos));
  221. }
  222.  
  223. #ifndef NO_PPCINLINE_STDARG
  224. #define AHI_GetAudioAttrs(a0, a1, tags...) \
  225.     ({ULONG _tags[] = { tags }; AHI_GetAudioAttrsA((a0), (a1), (struct TagItem *)_tags);})
  226. #endif /* !NO_PPCINLINE_STDARG */
  227.  
  228. #define    AHI_KillAudio()    _AHI_KillAudio(AHI_BASE_NAME)
  229.  
  230. static __inline void
  231. _AHI_KillAudio(void *AHIBase)
  232. {
  233. struct Caos    MyCaos;
  234.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  235. //    MyCaos.M68kStart    =    NULL;
  236. //    MyCaos.M68kSize        =    0;
  237.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  238. //    MyCaos.PPCStart        =    NULL;
  239. //    MyCaos.PPCSize        =    0;
  240.     MyCaos.caos_Un.Offset    =    (-54);
  241.     MyCaos.a6        =(ULONG) AHIBase;    
  242.     PPCCallOS(&MyCaos);
  243. }
  244.  
  245. #define    AHI_LoadModeFile(Private)    _AHI_LoadModeFile(AHI_BASE_NAME, Private)
  246.  
  247. static __inline ULONG
  248. _AHI_LoadModeFile(void *AHIBase, STRPTR Private)
  249. {
  250. struct Caos    MyCaos;
  251.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  252. //    MyCaos.M68kStart    =    NULL;
  253. //    MyCaos.M68kSize        =    0;
  254.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  255. //    MyCaos.PPCStart        =    NULL;
  256. //    MyCaos.PPCSize        =    0;
  257.     MyCaos.a0        =(ULONG) Private;
  258.     MyCaos.caos_Un.Offset    =    (-162);
  259.     MyCaos.a6        =(ULONG) AHIBase;    
  260.     return((ULONG)PPCCallOS(&MyCaos));
  261. }
  262.  
  263. #define    AHI_LoadSound(Sound, Type, Info, AudioCtrl)    _AHI_LoadSound(AHI_BASE_NAME, Sound, Type, Info, AudioCtrl)
  264.  
  265. static __inline ULONG
  266. _AHI_LoadSound(void *AHIBase, UWORD Sound, ULONG Type, APTR Info, struct AHIAudioCtrl *AudioCtrl)
  267. {
  268. struct Caos    MyCaos;
  269.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  270. //    MyCaos.M68kStart    =    NULL;
  271. //    MyCaos.M68kSize        =    0;
  272.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  273. //    MyCaos.PPCStart        =    NULL;
  274. //    MyCaos.PPCSize        =    0;
  275.     MyCaos.d0        =(ULONG) Sound;
  276.     MyCaos.d1        =(ULONG) Type;
  277.     MyCaos.a0        =(ULONG) Info;
  278.     MyCaos.a2        =(ULONG) AudioCtrl;
  279.     MyCaos.caos_Un.Offset    =    (-90);
  280.     MyCaos.a6        =(ULONG) AHIBase;    
  281.     return((ULONG)PPCCallOS(&MyCaos));
  282. }
  283.  
  284. #define    AHI_NextAudioID(Last_ID)    _AHI_NextAudioID(AHI_BASE_NAME, Last_ID)
  285.  
  286. static __inline ULONG
  287. _AHI_NextAudioID(void *AHIBase, ULONG Last_ID)
  288. {
  289. struct Caos    MyCaos;
  290.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  291. //    MyCaos.M68kStart    =    NULL;
  292. //    MyCaos.M68kSize        =    0;
  293.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  294. //    MyCaos.PPCStart        =    NULL;
  295. //    MyCaos.PPCSize        =    0;
  296.     MyCaos.d0        =(ULONG) Last_ID;
  297.     MyCaos.caos_Un.Offset    =    (-102);
  298.     MyCaos.a6        =(ULONG) AHIBase;    
  299.     return((ULONG)PPCCallOS(&MyCaos));
  300. }
  301.  
  302. #define    AHI_PlayA(Audioctrl, tagList)    _AHI_PlayA(AHI_BASE_NAME, Audioctrl, tagList)
  303.  
  304. static __inline void
  305. _AHI_PlayA(void *AHIBase, struct AHIAudioCtrl *Audioctrl, struct TagItem *tagList)
  306. {
  307. struct Caos    MyCaos;
  308.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  309. //    MyCaos.M68kStart    =    NULL;
  310. //    MyCaos.M68kSize        =    0;
  311.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  312. //    MyCaos.PPCStart        =    NULL;
  313. //    MyCaos.PPCSize        =    0;
  314.     MyCaos.a2        =(ULONG) Audioctrl;
  315.     MyCaos.a1        =(ULONG) tagList;
  316.     MyCaos.caos_Un.Offset    =    (-138);
  317.     MyCaos.a6        =(ULONG) AHIBase;    
  318.     PPCCallOS(&MyCaos);
  319. }
  320.  
  321. #ifndef NO_PPCINLINE_STDARG
  322. #define AHI_Play(a0, tags...) \
  323.     ({ULONG _tags[] = { tags }; AHI_PlayA((a0), (struct TagItem *)_tags);})
  324. #endif /* !NO_PPCINLINE_STDARG */
  325.  
  326. #define    AHI_RemoveAudioMode(Private)    _AHI_RemoveAudioMode(AHI_BASE_NAME, Private)
  327.  
  328. static __inline ULONG
  329. _AHI_RemoveAudioMode(void *AHIBase, ULONG Private)
  330. {
  331. struct Caos    MyCaos;
  332.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  333. //    MyCaos.M68kStart    =    NULL;
  334. //    MyCaos.M68kSize        =    0;
  335.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  336. //    MyCaos.PPCStart        =    NULL;
  337. //    MyCaos.PPCSize        =    0;
  338.     MyCaos.d0        =(ULONG) Private;
  339.     MyCaos.caos_Un.Offset    =    (-156);
  340.     MyCaos.a6        =(ULONG) AHIBase;    
  341.     return((ULONG)PPCCallOS(&MyCaos));
  342. }
  343.  
  344. #define    AHI_SampleFrameSize(SampleType)    _AHI_SampleFrameSize(AHI_BASE_NAME, SampleType)
  345.  
  346. static __inline ULONG
  347. _AHI_SampleFrameSize(void *AHIBase, ULONG SampleType)
  348. {
  349. struct Caos    MyCaos;
  350.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  351. //    MyCaos.M68kStart    =    NULL;
  352. //    MyCaos.M68kSize        =    0;
  353.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  354. //    MyCaos.PPCStart        =    NULL;
  355. //    MyCaos.PPCSize        =    0;
  356.     MyCaos.d0        =(ULONG) SampleType;
  357.     MyCaos.caos_Un.Offset    =    (-144);
  358.     MyCaos.a6        =(ULONG) AHIBase;    
  359.     return((ULONG)PPCCallOS(&MyCaos));
  360. }
  361.  
  362. #define    AHI_SetEffect(Effect, AudioCtrl)    _AHI_SetEffect(AHI_BASE_NAME, Effect, AudioCtrl)
  363.  
  364. static __inline ULONG
  365. _AHI_SetEffect(void *AHIBase, APTR Effect, struct AHIAudioCtrl *AudioCtrl)
  366. {
  367. struct Caos    MyCaos;
  368.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  369. //    MyCaos.M68kStart    =    NULL;
  370. //    MyCaos.M68kSize        =    0;
  371.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  372. //    MyCaos.PPCStart        =    NULL;
  373. //    MyCaos.PPCSize        =    0;
  374.     MyCaos.a0        =(ULONG) Effect;
  375.     MyCaos.a2        =(ULONG) AudioCtrl;
  376.     MyCaos.caos_Un.Offset    =    (-84);
  377.     MyCaos.a6        =(ULONG) AHIBase;    
  378.     return((ULONG)PPCCallOS(&MyCaos));
  379. }
  380.  
  381. #define    AHI_SetFreq(Channel, Freq, AudioCtrl, Flags)    _AHI_SetFreq(AHI_BASE_NAME, Channel, Freq, AudioCtrl, Flags)
  382.  
  383. static __inline void
  384. _AHI_SetFreq(void *AHIBase, UWORD Channel, ULONG Freq, struct AHIAudioCtrl *AudioCtrl, ULONG Flags)
  385. {
  386. struct Caos    MyCaos;
  387.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  388. //    MyCaos.M68kStart    =    NULL;
  389. //    MyCaos.M68kSize        =    0;
  390.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  391. //    MyCaos.PPCStart        =    NULL;
  392. //    MyCaos.PPCSize        =    0;
  393.     MyCaos.d0        =(ULONG) Channel;
  394.     MyCaos.d1        =(ULONG) Freq;
  395.     MyCaos.a2        =(ULONG) AudioCtrl;
  396.     MyCaos.d2        =(ULONG) Flags;
  397.     MyCaos.caos_Un.Offset    =    (-72);
  398.     MyCaos.a6        =(ULONG) AHIBase;    
  399.     PPCCallOS(&MyCaos);
  400. }
  401.  
  402. #define    AHI_SetSound(Channel, Sound, Offset, Length, AudioCtrl, Flags)    _AHI_SetSound(AHI_BASE_NAME, Channel, Sound, Offset, Length, AudioCtrl, Flags)
  403.  
  404. static __inline void
  405. _AHI_SetSound(void *AHIBase, UWORD Channel, UWORD Sound, ULONG Offset, LONG Length, struct AHIAudioCtrl *AudioCtrl, ULONG Flags)
  406. {
  407. struct Caos    MyCaos;
  408.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  409. //    MyCaos.M68kStart    =    NULL;
  410. //    MyCaos.M68kSize        =    0;
  411.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  412. //    MyCaos.PPCStart        =    NULL;
  413. //    MyCaos.PPCSize        =    0;
  414.     MyCaos.d0        =(ULONG) Channel;
  415.     MyCaos.d1        =(ULONG) Sound;
  416.     MyCaos.d2        =(ULONG) Offset;
  417.     MyCaos.d3        =(ULONG) Length;
  418.     MyCaos.a2        =(ULONG) AudioCtrl;
  419.     MyCaos.d4        =(ULONG) Flags;
  420.     MyCaos.caos_Un.Offset    =    (-78);
  421.     MyCaos.a6        =(ULONG) AHIBase;    
  422.     PPCCallOS(&MyCaos);
  423. }
  424.  
  425. #define    AHI_SetVol(Channel, Volume, Pan, AudioCtrl, Flags)    _AHI_SetVol(AHI_BASE_NAME, Channel, Volume, Pan, AudioCtrl, Flags)
  426.  
  427. static __inline void
  428. _AHI_SetVol(void *AHIBase, UWORD Channel, Fixed Volume, sposition Pan, struct AHIAudioCtrl *AudioCtrl, ULONG Flags)
  429. {
  430. struct Caos    MyCaos;
  431.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  432. //    MyCaos.M68kStart    =    NULL;
  433. //    MyCaos.M68kSize        =    0;
  434.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  435. //    MyCaos.PPCStart        =    NULL;
  436. //    MyCaos.PPCSize        =    0;
  437.     MyCaos.d0        =(ULONG) Channel;
  438.     MyCaos.d1        =(ULONG) Volume;
  439.     MyCaos.d2        =(ULONG) Pan;
  440.     MyCaos.a2        =(ULONG) AudioCtrl;
  441.     MyCaos.d3        =(ULONG) Flags;
  442.     MyCaos.caos_Un.Offset    =    (-66);
  443.     MyCaos.a6        =(ULONG) AHIBase;    
  444.     PPCCallOS(&MyCaos);
  445. }
  446.  
  447. #define    AHI_UnloadSound(Sound, Audioctrl)    _AHI_UnloadSound(AHI_BASE_NAME, Sound, Audioctrl)
  448.  
  449. static __inline void
  450. _AHI_UnloadSound(void *AHIBase, UWORD Sound, struct AHIAudioCtrl *Audioctrl)
  451. {
  452. struct Caos    MyCaos;
  453.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  454. //    MyCaos.M68kStart    =    NULL;
  455. //    MyCaos.M68kSize        =    0;
  456.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  457. //    MyCaos.PPCStart        =    NULL;
  458. //    MyCaos.PPCSize        =    0;
  459.     MyCaos.d0        =(ULONG) Sound;
  460.     MyCaos.a2        =(ULONG) Audioctrl;
  461.     MyCaos.caos_Un.Offset    =    (-96);
  462.     MyCaos.a6        =(ULONG) AHIBase;    
  463.     PPCCallOS(&MyCaos);
  464. }
  465.  
  466. #endif /* SASC Pragmas */
  467. #endif /* !_PPCPRAGMA_AHI_H */
  468.